String面试题

对于字符串，其对象的引用都是存储在栈中的，如果是编译期已经创建好(直接用双引号定义的)的就存储在常量池中，如果是运行期（new出来的）才能确定的就存储在堆中。对于equals相等的字符串，在常量池中永远只有一份，在堆中有多份。

面试题

第一题：==与equals()的区别  
1.判断定义为String类型的s1和s2是否相等  
    String s1 = "abc";  
    String s2 = "abc";  
    System.out.println(s1 == s2);                       
    System.out.println(s1.equals(s2));           
2.下面这句话在内存中创建了几个对象?  
    String s1 = new String("abc");              
3.判断定义为String类型的s1和s2是否相等  
    String s1 = new String("abc");              
    String s2 = "abc";  
    System.out.println(s1 == s2);          
    System.out.println(s1.equals(s2));  
4.判断定义为String类型的s1和s2是否相等  
    String s1 = "a" + "b" + "c";  
    String s2 = "abc";  
    System.out.println(s1 == s2);          
    System.out.println(s1.equals(s2));  
5.判断定义为String类型的s1和s2是否相等  
    String s1 = "ab";  
    String s2 = "abc";  
    String s3 = s1 + "c";  
    System.out.println(s3 == s2);  
    System.out.println(s3.equals(s2));  
  
解答:  
    上面所有equals()方法的结果都是true,因为equals()方法在String类中,我们来看下API中的解释  
equals:  
    将此字符串与指定的对象比较。当且仅当该参数不为null，并且是与此对象表示相同字符序列的 String 对象时，结果才为true。  
    因为String类中字符串是常量；它们的值在创建之后不能更改  
  
第一题中:  
    //常量池中没有这个字符串对象,就创建一个,如果有直接用即可  
    String s1 = "abc";  
    String s2 = "abc";  
    System.out.println(s1 == s2);             //==号比较的是地址值,true      
    System.out.println(s1.equals(s2));         //比较的是字符串的内容:true  
第二题:  
    //创建几个对象  
    //创建两个对象,一个在常量池中,一个在堆内存中  
    String s1 = new String("abc");          
    System.out.println(s1);  
第三题:  
    String s1 = new String("abc");            //录的是堆内存对象的地址值          
    String s2 = "abc";                        //记录的是常量池中的地址值  
    System.out.println(s1 == s2);             //false  
第四题:  
    //byte b = 3 + 4;                        //在编译时就变成7,把7赋值给b,常量优化机制  
    String s1 = "a" + "b" + "c";            //java中有常量优化机制,在编译时期就能确定s2的值为"abc",所以编译时期,在常量池中创建"abc"  
    String s2 = "abc";                        //执行到这里时常量池中已经有了"abc",所以就不再创建,所以s1和s2指向的是常量池中同一个字符串常量"abc"  
    System.out.println(s1 == s2);             //true,java中有常量优化机制      
第五题:  
    String s1 = "ab";  
    String s2 = "abc";  
    String s3 = s1 + "c";                    //s1是变量,s1与常量"c"相加  
    System.out.println(s3 == s2);            //false  
    /*理解第五题需要懂得String相加的时候，底层是通过stringbuiler的append和tostring来完成的。而tostring是通过构造函数来实现的 
    也就是相当于是一个new的操作，所以为false。但是append操作的时候是在同一个对象上面操作的，因此引用所指向的地址是会发生改变的 
    */  
    /* 
    两个变量的相加所以编译器无法优化，s1+s2即等同于(new StringBuilder(String.valueOf(s1))).append(s2).toString();  
    在运行时，会有新的String地址空间的分配，而不是指向缓冲池中的“ab” 
    */  
第六题：  
    final String s1 = "ab";  
    final String s2 = "abc";  
    final String s3 = s1 + "c";  
    System.out.println(s3 == s2);//true  
    System.out.println(s3.equals(s2));//true  
    /*final类型编译器进行了优化所以相同，就相当于s3="ab"+'c'的时候程序编译的时候常量优化操作*/  
  
第二题：String字符串与BufferString的传递问题  
/* 
基本数据类型的值传递,不改变其值 
引用数据类型的值传递,改变其值 
String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的 
 */  
public class Test {  
    public static void main(String args[]){  
        String s = "heima";  
        System.out.println(s);  
        change(s);  
        System.out.println(s);  
  
        System.out.println("---------------------");  
        StringBuffer sb = new StringBuffer();  
        sb.append("heima");  
        System.out.println(sb);  
        change(sb);  
        System.out.println(sb);  
    }  
    public static void change(StringBuffer sb) {  
        //调用该方法时实际参数的sb和形式参数的sb指向的是同一个对象(StringBuffer容器)  
        //方法内部又在该容器里添加了"itcast",所以方法结束时,局部变量的sb消失,但是实际参数的sb所指向的容器的内部的内容已经发生了改变  
        sb.append("itcast");  
        //相当于c++中指针的操作  StringBuffer是可变的，string是不可变的，后者是返回一个新的对象  
    }  
    public static void change(String s) {  
        s += "itcast";  
        //return s;  
    }  
    //为了便于大家理解,再建立一个changeString方法  
    public static void changeString(String str) {  
        //因为str是属于局部变量,在调用该方法是实际参数s和形式参数str指向同一个字符串对象  
        //但是在方法内部将str又指向了一个新的字符串对象,而此时s还是指向的原来的字符串对象  
        //changeString方法执行完毕,局部变量str消失,方法内部产生的新的字符串对象称为垃圾  
        //但是s还是指向的原有的字符串对象,并没有改变  
        str += "itcast";  
    }  
  
}

StringBuffer与StringBuilder的区别

1. StringBuffer 与 StringBuilder 中的方法和功能完全是等价的，
2. 只是StringBuffer 中的方法大都采用了 synchronized 关键字进行修饰，因此是线程安全的，而StringBuilder 没有这个修饰，可以被认为是线程不安全的。
3. 在单线程程序下，StringBuilder效率更快，因为它不需要加锁，不具备多线程安全而StringBuffer则每次都需要判断锁，效率相对更低。

StringBuffer 始于 JDK 1.0 
StringBuilder 始于 JDK 1.5 

从 JDK 1.5 开始，带有字符串变量的连接操作（+），JVM 内部采用的是 
StringBuilder 来实现的，而之前这个操作是采用 StringBuffer 实现的。

JVM内部采用了StringBuffer来连接字符串了，那么我们自己就不用用StringBuffer，直接用”+“就行了吧！“。是么？当然不是了。俗话说”存在既有它的理由”，让我们继续看后面的循环对应的字节码。
因为每次执行“+”操作时jvm都要new一个StringBuffer对象来处理字符串的连接，这在涉及很多的字符串连接操作时开销会很大。